juce/source/extras/the jucer/src/model/paintelements/jucer_PaintElementGroup.h

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #ifndef __JUCER_PAINTELEMENTGROUP_JUCEHEADER__
  27 #define __JUCER_PAINTELEMENTGROUP_JUCEHEADER__
  28
  29 #include "jucer_PaintElement.h"
  30 #include "../jucer_ObjectTypes.h"
  31
  32
  33 //==============================================================================
  34 /**
  35 */
  36 class PaintElementGroup   : public PaintElement
  37 {
  38 public:
  39     //==============================================================================
  40     PaintElementGroup (PaintRoutine* owner)
  41         : PaintElement (owner, "Group")
  42     {
  43     }
  44
  45     ~PaintElementGroup() {}
  46
  47     //==============================================================================
  48     void ungroup (const bool undoable)
  49     {
  50         getOwner()->getSelectedElements().deselectAll();
  51         getOwner()->getSelectedPoints().deselectAll();
  52
  53         const int index = getOwner()->indexOfElement (this);
  54
  55         for (int i = 0; i < subElements.size(); ++i)
  56         {
  57             XmlElement* const xml = subElements.getUnchecked(i)->createXml();
  58
  59             PaintElement* newOne = getOwner()->addElementFromXml (*xml, index, undoable);
  60             getOwner()->getSelectedElements().addToSelection (newOne);
  61
  62             delete xml;
  63         }
  64
  65         getOwner()->removeElement (this, undoable);
  66     }
  67
  68     static void groupSelected (PaintRoutine* const routine)
  69     {
  70         if (routine->getSelectedElements().getNumSelected() > 1)
  71         {
  72             PaintElementGroup* newGroup = new PaintElementGroup (routine);
  73
  74             int frontIndex = -1;
  75
  76             for (int i = 0; i < routine->getNumElements(); ++i)
  77             {
  78                 if (routine->getSelectedElements().isSelected (routine->getElement (i)))
  79                 {
  80                     XmlElement* xml = routine->getElement(i)->createXml();
  81
  82                     PaintElement* newOne = ObjectTypes::createElementForXml (xml, routine);
  83                     if (newOne != 0)
  84                         newGroup->subElements.add (newOne);
  85
  86                     delete xml;
  87
  88                     if (i > frontIndex)
  89                         frontIndex = i;
  90                 }
  91             }
  92
  93             routine->deleteSelected();
  94
  95             PaintElement* const g = routine->addNewElement (newGroup, frontIndex, true);
  96             routine->getSelectedElements().selectOnly (g);
  97         }
  98     }
  99
 100     int getNumElements() const throw()                              { return subElements.size(); }
 101
 102     PaintElement* getElement (const int index) const throw()        { return subElements [index]; }
 103
 104     int indexOfElement (const PaintElement* element) const throw()  { return subElements.indexOf (element); }
 105
 106     bool containsElement (const PaintElement* element) const
 107     {
 108         if (subElements.contains (element))
 109             return true;
 110
 111         for (int i = subElements.size(); --i >= 0;)
 112         {
 113             PaintElementGroup* pg = dynamic_cast <PaintElementGroup*> (subElements.getUnchecked(i));
 114
 115             if (pg != 0 && pg->containsElement (element))
 116                 return true;
 117         }
 118
 119         return false;
 120     }
 121
 122     //==============================================================================
 123     void setInitialBounds (int parentWidth, int parentHeight)
 124     {
 125     }
 126
 127     const Rectangle<int> getCurrentBounds (const Rectangle<int>& parentArea) const
 128     {
 129         Rectangle<int> r;
 130
 131         if (subElements.size() > 0)
 132         {
 133             r = subElements.getUnchecked(0)->getCurrentBounds (parentArea);
 134
 135             for (int i = 1; i < subElements.size(); ++i)
 136                 r = r.getUnion (subElements.getUnchecked(i)->getCurrentBounds (parentArea));
 137         }
 138
 139         return r;
 140     }
 141
 142     void setCurrentBounds (const Rectangle<int>& b, const Rectangle<int>& parentArea, const bool undoable)
 143     {
 144         Rectangle<int> newBounds (b);
 145         newBounds.setSize (jmax (1, newBounds.getWidth()),
 146                            jmax (1, newBounds.getHeight()));
 147
 148         const Rectangle<int> current (getCurrentBounds (parentArea));
 149
 150         if (newBounds != current)
 151         {
 152             const int dx = newBounds.getX() - current.getX();
 153             const int dy = newBounds.getY() - current.getY();
 154
 155             const double scaleStartX = current.getX();
 156             const double scaleStartY = current.getY();
 157             const double scaleX = newBounds.getWidth() / (double) current.getWidth();
 158             const double scaleY = newBounds.getHeight() / (double) current.getHeight();
 159
 160             for (int i = 0; i < subElements.size(); ++i)
 161             {
 162                 PaintElement* const e = subElements.getUnchecked(i);
 163
 164                 Rectangle<int> pos (e->getCurrentBounds (parentArea));
 165
 166                 const int newX = roundToInt ((pos.getX() - scaleStartX) * scaleX + scaleStartX + dx);
 167                 const int newY = roundToInt ((pos.getY() - scaleStartY) * scaleY + scaleStartY + dy);
 168
 169                 pos.setBounds (newX, newY,
 170                                roundToInt ((pos.getRight() - scaleStartX) * scaleX + scaleStartX + dx) - newX,
 171                                roundToInt ((pos.getBottom() - scaleStartY) * scaleY + scaleStartY + dy) - newY);
 172
 173                 e->setCurrentBounds (pos, parentArea, undoable);
 174             }
 175         }
 176     }
 177
 178     //==============================================================================
 179     void draw (Graphics& g, const ComponentLayout* layout, const Rectangle<int>& parentArea)
 180     {
 181         for (int i = 0; i < subElements.size(); ++i)
 182             subElements.getUnchecked(i)->draw (g, layout, parentArea);
 183     }
 184
 185     void getEditableProperties (Array <PropertyComponent*>& properties)
 186     {
 187         properties.add (new UngroupProperty (this));
 188     }
 189
 190     void fillInGeneratedCode (GeneratedCode& code, String& paintMethodCode)
 191     {
 192         for (int i = 0; i < subElements.size(); ++i)
 193             subElements.getUnchecked(i)->fillInGeneratedCode (code, paintMethodCode);
 194     }
 195
 196     static const char* getTagName() throw()        { return "GROUP"; }
 197
 198     XmlElement* createXml() const
 199     {
 200         XmlElement* e = new XmlElement (getTagName());
 201
 202         for (int i = 0; i < subElements.size(); ++i)
 203         {
 204             XmlElement* const sub = subElements.getUnchecked(i)->createXml();
 205             e->addChildElement (sub);
 206         }
 207
 208         return e;
 209     }
 210
 211     bool loadFromXml (const XmlElement& xml)
 212     {
 213         if (xml.hasTagName (getTagName()))
 214         {
 215             forEachXmlChildElement (xml, e)
 216             {
 217                 PaintElement* const pe = ObjectTypes::createElementForXml (e, owner);
 218
 219                 if (pe != 0)
 220                     subElements.add (pe);
 221             }
 222
 223             return true;
 224         }
 225         else
 226         {
 227             jassertfalse
 228             return false;
 229         }
 230     }
 231
 232 private:
 233     OwnedArray <PaintElement> subElements;
 234
 235     class UngroupProperty  : public ButtonPropertyComponent
 236     {
 237     public:
 238         UngroupProperty (PaintElementGroup* const element_)
 239             : ButtonPropertyComponent ("ungroup", false),
 240               element (element_)
 241         {
 242         }
 243
 244         void buttonClicked()
 245         {
 246             element->ungroup (true);
 247         }
 248
 249         const String getButtonText() const
 250         {
 251             return "Ungroup";
 252         }
 253
 254     private:
 255         PaintElementGroup* const element;
 256     };
 257 };
 258
 259
 260 #endif   // __JUCER_PAINTELEMENTGROUP_JUCEHEADER__